package com.taotao.manage.service;

import java.util.Date;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import com.github.abel533.entity.Example;
import com.github.abel533.entity.Example.Criteria;
import com.github.abel533.mapper.Mapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.taotao.manage.pojo.BasePojo;

/**
 * @Description:公共的service
 * @author:     mingxu
 */

public abstract class BaseService<T extends BasePojo> {

	//方式一：抽象方法---所有子类需要实现该抽象方法，并提供具体的mapper对象
	//public abstract Mapper<T> getMapper();

	//方式二：spring4提供了对泛型注入的支持，它会根据T来定位到对应的mapper实现类
	@Autowired
	private Mapper<T> mapper;

	/**
	 * @Description:根据主键查询单个对象
	 * @param id
	 * @return
	 * @author mingxu
	 */
	public T queryById(Object id) {

		return mapper.selectByPrimaryKey(id);
	}

	/**
	 * 根据主键查询单个对象
	 * @param record
	 * @return
	 */
	public List<T> queryListByRecord(T record) {
		return this.mapper.select(record);
	}

	/**
	* 查询全部
	* @return
	*/
	public List<T> queryAll() {
		return this.mapper.select(null);
	}

	/**
	 * 根据条件查询1条数据。
	 * 注意：请保证条件至多只有一个匹配
	 * @param record
	 * @return
	 */
	public T queryOne(T record) {
		return this.mapper.selectOne(record);
	}

	/**
	 * 统计符合条件的结果数
	 * @param record
	 * @return
	 */
	public Integer count(T record) {
		return this.mapper.selectCount(record);
	}

	/**
	 * 根据条件查询多条数据
	 * @param record
	 * @return
	 */
	public List<T> queryListByWhere(T record) {
		return this.mapper.select(record);
	}

	/**
	 * 根据条件分页查询
	 * @param record
	 * @return
	 */
	public PageInfo<T> queryPageListByWhere(T record, Integer page, Integer rows) {
		PageHelper.startPage(page, rows);
		List<T> list = this.mapper.select(record);
		return new PageInfo<>(list);
	}

	/**
	 * @Description: 分页查询数据并排序
	 * @param clazz
	 * @param orderByClause 排序的字段和规则
	 * @param page
	 * @param rows
	 * @return
	 * @author mingxu
	 */
	public PageInfo<T> queryPageListByWhereOrderBy(Class<?> clazz, String orderByClause, Integer page, Integer rows) {
		//启动分页查询插件
		PageHelper.startPage(page, rows);

		//设置通用mapper查询条件
		Example example = new Example(clazz);
		//设置排序的字段和规则
		example.setOrderByClause(orderByClause);
		List<T> list = this.mapper.selectByExample(example);

		//封装数据到PageInfo
		return new PageInfo<>(list);
	}

	/**
	 * 
	 * @param pageNum 页码
	 * @param pageSize 每页条数
	 * @param clazz 操作对象
	 * @param orderByClause 排序条件 eg:id desc
	 * @param paramMap : 条件map集合
	 * @return
	 */
	public PageInfo<T> queryPageListByWhereOrderBy(Integer pageNum, Integer pageSize,
			@SuppressWarnings("rawtypes") Class clazz, String orderByClause, Map<String, Object> paramMap) {
		//启用分页助手  基于拦截器的机制 该行代码必须放在查询代码的前面
		PageHelper.startPage(pageNum, pageSize);
		Example example = new Example(clazz);
		example.setOrderByClause(orderByClause);
		Criteria criteria = example.createCriteria();
		if (paramMap != null && !paramMap.isEmpty()) {
			for (String key : paramMap.keySet()) {
				criteria.andEqualTo(key, paramMap.get(key));
			}
		}
		List<T> list = this.mapper.selectByExample(example);
		return new PageInfo<T>(list);

	}

	/**
	 * @Description:插入数据数据
	 * @param record
	 * @return
	 * @author mingxu
	 */
	public Integer save(T record) {
		record.setCreated(new Date());
		record.setUpdated(record.getCreated());
		return this.mapper.insert(record);

	}

	/**
	 * 插入数据,只操作record中的非空属性
	 * @param record
	 * @return
	 */
	public Integer saveSelective(T record) {
		record.setCreated(new Date());
		record.setUpdated(record.getCreated());
		return this.mapper.insertSelective(record);
	}

	/**
	 * 更新：更新设置过值的字段，没有的保持不变
	 * 注意：主键不能为空
	 * @param record
	 * @return
	 */
	public Boolean updateById(T record) {
		record.setUpdated(new Date());
		return this.mapper.updateByPrimaryKeySelective(record) == 1;
	}

	public void updateSelective(T record, Object example) {
		record.setUpdated(new Date());
		this.mapper.updateByExampleSelective(record, example);
	}


	/**
	 * 根据id删除对象
	 * @param id
	 * @return
	 */
	public Boolean deleteById(Object id) {
		return this.mapper.deleteByPrimaryKey(id) == 1;
	}

	/**
	 * 根据集合删除多个对象
	 * @param property
	 * @param ids
	 * @param clazz
	 * @return
	 */
	public Integer deleteByIds(String property, List<Object> ids, @SuppressWarnings("rawtypes") Class clazz) {
		Example example = new Example(clazz);
		Criteria criteria = example.createCriteria();
		criteria.andIn(property, ids);
		return this.mapper.deleteByExample(example);
	}

	/**
	 * 根据条件删除多个对象
	 * @param record
	 * @return
	 */
	public Integer deleteByWhere(T record) {
		return this.mapper.delete(record);
	}

}
